﻿using BLL.Interfaces;
using DAL.DBInteractions;
using POCOS;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BLL
{
    public  class AuteurServices : IAuteurServices
    {

        private readonly IUnitOfWork _unitofwork;

        public AuteurServices(IUnitOfWork unitofwork)
        {
            this._unitofwork = unitofwork;
        }

        public AuteurServices()
        {

        }

        #region AuteursService Memebers

        public IEnumerable<Auteur> GetAuteur()
        {
            return _unitofwork.AuteurRepository.GetAll();
        }
        public Auteur GetAuteurById(int id)
        {
            return _unitofwork.AuteurRepository.GetById(id);
        }
        public void CreateAuteur(Auteur Auteur)
        {
            _unitofwork.AuteurRepository.Add(Auteur);
            _unitofwork.Commit();
        }
        public Auteur Find(int id)
        {
            return _unitofwork.AuteurRepository.Find(x => x.UserProfileId == id).FirstOrDefault();
        }

        public void UpdateAuteur(Auteur Auteur)
        {
            _unitofwork.AuteurRepository.Update(Auteur);
            _unitofwork.Commit();
        }


        public void DeleteAuteur(int id)
        {
            _unitofwork.AuteurRepository.Delete(GetAuteurById(id));
            _unitofwork.Commit();
        }

        public List<Auteur> GetAuthors(int startIndex, int count, string sorting)
        {
            IEnumerable<Auteur> query = _unitofwork.AuteurRepository.GetAll();


            //Sorting
            //This ugly code is used just for demonstration.
            //Normally, Incoming sorting text can be directly appended to an SQL query.
            if (string.IsNullOrEmpty(sorting) || sorting.Equals("Name ASC"))
            {
                query = query.OrderBy(p => p.Name);
            }
            else if (sorting.Equals("Name DESC"))
            {
                query = query.OrderByDescending(p => p.Name);
            }

            else if (sorting.Equals("Lastname  ASC"))
            {
                query = query.OrderBy(p => p.Lastname);
            }

            else if (sorting.Equals("Profil  DESC"))
            {
                query = query.OrderByDescending(p => p.Profil);
            }


            else if (sorting.Equals("UserProfileId  ASC"))
            {
                query = query.OrderBy(p => p.UserProfileId);
            }

            else if (sorting.Equals("Adressmail  ASC"))
            {
                query = query.OrderBy(p => p.Adressmail);
            }
           
        

            else
            {
                query = query.OrderBy(p => p.Name); //Default!
            }

            return count > 0
                       ? query.Skip(startIndex).Take(count).ToList() //Paging
                       : query.ToList(); //No paging
        }

        public int GetAuthorCount()
        {
            return _unitofwork.AuteurRepository.GetAll().Count();

        }



        public void SaveAuteur()
        {
            _unitofwork.Commit();
        }


        #endregion

        public List<Auteur> GetAuteurs()
        {
            return _unitofwork.AuteurRepository.GetAll().ToList();
        }
    }
}
